Amiga Format CD 7

home *** CD-ROM | disk | FTP | other *** search

/ Amiga Format CD 7 / Amiga Format AFCD07 (Dec 1996, Issue 91).iso / serious / shareware / programming / emacs-complete / fsf / emacs / info / emacs-3 < prev next >

Wrap

GNU Info File | 1994-10-06 | 48.6 KB | 1,193 lines

This is Info file ../info/emacs, produced by Makeinfo-1.54 from the input file emacs.texi. File: emacs, Node: Position Info, Next: Arguments, Prev: Continuation Lines, Up: Basic Cursor Position Information =========================== Here are commands to get information about the size and position of parts of the buffer, and to count lines. `M-x what-page' Print page number of point, and line number within page. `M-x what-line' Print line number of point in the buffer. `M-x line-number-mode' Toggle automatic display of current line number. `M-=' Print number of lines in the current region (`count-lines-region'). `C-x =' Print character code of character after point, character position of point, and column of point (`what-cursor-position'). There are two commands for printing the current line number. `M-x what-line' computes the current line number and displays it in the echo area. `M-x line-number-mode' enables display of the current line number in the mode line; once you turn this on, the number updates as you move point, so it remains valid all the time. *Note Mode Line::. Line numbers count from one at the beginning of the buffer. To go to a given line by number, use `M-x goto-line'; it prompts you for the line number. By contrast, `M-x what-page' counts pages from the beginning of the file, and counts lines within the page, printing both numbers. *Note Pages::. While on this subject, we might as well mention `M-=' (`count-lines-region'), which prints the number of lines in the region (*note Mark::.). *Note Pages::, for the command `C-x l' which counts the lines in the current page. The command `C-x =' (`what-cursor-position') can be used to find out the column that the cursor is in, and other miscellaneous information about point. It prints a line in the echo area that looks like this: Char: x (0170) point=65986 of 563027(12%) x=44 (In fact, this is the output produced when point is before the `x=44' in the example.) The two values after `Char:' describe the character that follows point, first by showing it and second by giving its octal character code. `point=' is followed by the position of point expressed as a character count. The front of the buffer counts as position 1, one character later as 2, and so on. The next, larger number is the total number of characters in the buffer. Afterward in parentheses comes the position expressed as a percentage of the total size. `x=' is followed by the horizontal position of point, in columns from the left edge of the window. If the buffer has been narrowed, making some of the text at the beginning and the end temporarily inaccessible, `C-x =' prints additional text describing the currently accessible range. For example, it might display this: Char: x (0170) point=65986 of 563025(12%) <65102 - 68533> x=44 where the two extra numbers give the smallest and largest character position that point is allowed to assume. The characters between those two positions are the accessible ones. *Note Narrowing::. If point is at the end of the buffer (or the end of the accessible part), `C-x =' omits any description of the character after point. The output looks like this: point=563026 of 563025(100%) x=0 File: emacs, Node: Arguments, Prev: Position Info, Up: Basic Numeric Arguments ================= Any Emacs command can be given a "numeric argument" (also called a "prefix argument"). Some commands interpret the argument as a repetition count. For example, `C-f' with an argument of ten moves forward ten characters instead of one. With these commands, no argument is equivalent to an argument of one. Negative arguments tell most such commands to move or act in the opposite direction. If your terminal keyboard has a META key, the easiest way to specify a numeric argument is to type digits and/or a minus sign while holding down the the META key. For example, M-5 C-n would move down five lines. The characters `Meta-1', `Meta-2', and so on, as well as `Meta--', do this because they are keys bound to commands (`digit-argument' and `negative-argument') that are defined to contribute to an argument for the next command. Another way of specifying an argument is to use the `C-u' (`universal-argument') command followed by the digits of the argument. With `C-u', you can type the argument digits without holding down modifier keys; `C-u' works on all terminals. To type a negative argument, type a minus sign after `C-u'. Just a minus sign without digits normally means -1. `C-u' followed by a character which is neither a digit nor a minus sign has the special meaning of "multiply by four". It multiplies the argument for the next command by four. `C-u' twice multiplies it by sixteen. Thus, `C-u C-u C-f' moves forward sixteen characters. This is a good way to move forward "fast", since it moves about 1/5 of a line in the usual size screen. Other useful combinations are `C-u C-n', `C-u C-u C-n' (move down a good fraction of a screen), `C-u C-u C-o' (make "a lot" of blank lines), and `C-u C-k' (kill four lines). Some commands care only about whether there is an argument, and not about its value. For example, the command `M-q' (`fill-paragraph') with no argument fills text; with an argument, it justifies the text as well. (*Note Filling::, for more information on `M-q'.) Plain `C-u' is a handy way of providing an argument for such commands. Some commands use the value of the argument as a repeat count, but do something peculiar when there is no argument. For example, the command `C-k' (`kill-line') with argument N kills N lines, including their terminating newlines. But `C-k' with no argument is special: it kills the text up to the next newline, or, if point is right at the end of the line, it kills the newline itself. Thus, two `C-k' commands with no arguments can kill a nonblank line, just like `C-k' with an argument of one. (*Note Killing::, for more information on `C-k'.) A few commands treat a plain `C-u' differently from an ordinary argument. A few others may treat an argument of just a minus sign differently from an argument of -1. These unusual cases are described when they come up; they are always for reasons of convenience of use of the individual command. You can use a numeric argument to insert multiple copies of a character. This is straightforward unless the character is a digit; for example, `C-u 6 4 a' inserts 64 copies of the character `a'. But this does not work for inserting digits; `C-u 6 4 1' specifies an argument of 641, rather than inserting anything. To separate the digit to insert from the argument, type another `C-u'; for example, `C-u 6 4 C-u 1' does insert 64 copies of the character `1'. We use the term "prefix argument" as well as "numeric argument" to emphasize that you type the argument before the command, and to distinguish these arguments from minibuffer arguments that come after the command. File: emacs, Node: Minibuffer, Next: M-x, Prev: Basic, Up: Top The Minibuffer ************** The "minibuffer" is the facility used by Emacs commands to read arguments more complicated than a single number. Minibuffer arguments can be file names, buffer names, Lisp function names, Emacs command names, Lisp expressions, and many other things, depending on the command reading the argument. You can use the usual Emacs editing commands in the minibuffer to edit the argument text. When the minibuffer is in use, it appears in the echo area, and the terminal's cursor moves there. The beginning of the minibuffer line displays a "prompt" which says what kind of input you should supply and how it will be used. Often this prompt is derived from the name of the command that the argument is for. The prompt normally ends with a colon. Sometimes a "default argument" appears in parentheses after the colon; it too is part of the prompt. The default will be used as the argument value if you enter an empty argument (e.g., just type RET). For example, commands that read buffer names always show a default, which is the name of the buffer that will be used if you type just RET. The simplest way to enter a minibuffer argument is to type the text you want, terminated by RET which exits the minibuffer. You can cancel the command that wants the argument, and get out of the minibuffer, by typing `C-g'. Since the minibuffer uses the screen space of the echo area, it can conflict with other ways Emacs customarily uses the echo area. Here is how Emacs handles such conflicts: * If a command gets an error while you are in the minibuffer, this does not cancel the minibuffer. However, the echo area is needed for the error message and therefore the minibuffer itself is hidden for a while. It comes back after a few seconds, or as soon as you type anything. * If in the minibuffer you use a command whose purpose is to print a message in the echo area, such as `C-x =', the message is printed normally, and the minibuffer is hidden for a while. It comes back after a few seconds, or as soon as you type anything. * Echoing of keystrokes does not take place while the minibuffer is in use. * Menu: * File: Minibuffer File. Entering file names with the minibuffer. * Edit: Minibuffer Edit. How to edit in the minibuffer. * Completion:: An abbreviation facility for minibuffer input. * Minibuffer History:: Reusing recent minibuffer arguments. * Repetition:: Re-executing commands that used the minibuffer. File: emacs, Node: Minibuffer File, Next: Minibuffer Edit, Up: Minibuffer Minibuffers for File Names ========================== Sometimes the minibuffer starts out with text in it. For example, when you are supposed to give a file name, the minibuffer starts out containing the "default directory", which ends with a slash. This is to inform you which directory the file will be found in if you do not specify a directory. For example, the minibuffer might start out with these contents: Find File: /u2/emacs/src/ where `Find File: ' is the prompt. Typing `buffer.c' specifies the file `/u2/emacs/src/buffer.c'. To find files in nearby directories, use `..'; thus, if you type `../lisp/simple.el', you will get the file named `/u2/emacs/lisp/simple.el'. Alternatively, you can kill with `M-DEL' the directory names you don't want (*note Words::.). If you don't want any of the default, you can kill it with `C-a C-k'. But you don't need to kill the default; you can simply ignore it. Insert an absolute file name, one starting with a slash or a tilde, after the default directory. For example, to specify the file `/etc/termcap', just insert that name, giving these minibuffer contents: Find File: /u2/emacs/src//etc/termcap Two slashes in a row are not normally meaningful in a file name, but they are allowed in GNU Emacs. They mean, "ignore everything before the second slash in the pair." Thus, `/u2/emacs/src/' is ignored in the example above, and you get the file `/etc/termcap'. If you set `insert-default-directory' to `nil', the default directory is not inserted in the minibuffer. This way, the minibuffer starts out empty. But the name you type, if relative, is still interpreted with respect to the same default directory. File: emacs, Node: Minibuffer Edit, Next: Completion, Prev: Minibuffer File, Up: Minibuffer Editing in the Minibuffer ========================= The minibuffer is an Emacs buffer (albeit a peculiar one), and the usual Emacs commands are available for editing the text of an argument you are entering. Since RET in the minibuffer is defined to exit the minibuffer, you can't use it to insert a newline in the minibuffer. To do that, type `C-o' or `C-q LFD'. (Recall that a newline is really the LFD character.) The minibuffer has its own window which always has space on the screen but acts as if it were not there when the minibuffer is not in use. When the minibuffer is in use, its window is just like the others; you can switch to another window with `C-x o', edit text in other windows and perhaps even visit more files, before returning to the minibuffer to submit the argument. You can kill text in another window, return to the minibuffer window, and then yank the text to use it in the argument. *Note Windows::. There are some restrictions on the use of the minibuffer window, however. You cannot switch buffers in it--the minibuffer and its window are permanently attached. Also, you cannot split or kill the minibuffer window. But you can make it taller in the normal fashion with `C-x ^'. If you enable Resize-Minibuffer mode, then the minibuffer window expands vertically as necessary to hold the text that you put in the minibuffer. Use `M-x resize-minibuffer-mode' to enable or disable this minor mode (*note Minor Modes::.). If while in the minibuffer you issue a command that displays help text of any sort in another window, you can use the `C-M-v' command while in the minibuffer to scroll the help text. This lasts until you exit the minibuffer. This feature is especially useful if a completing minibuffer gives you a list of possible completions. *Note Other Window::. Emacs normally disallows most commands that use the minibuffer while the minibuffer is selected. This rule is to prevent recursive minibuffers from confusing novice users. If you want to be able to use such commands in the minibuffer, set the variable `enable-recursive-minibuffers' to a non-`nil' value. File: emacs, Node: Completion, Next: Minibuffer History, Prev: Minibuffer Edit, Up: Minibuffer Completion ========== For certain kinds of arguments, you can use "completion" to enter the argument value. Completion means that you type part of the argument, then Emacs visibly fills in the rest, or as much as can be determined from the part you have typed. When completion is available, certain keys--TAB, RET, and SPC--are rebound to complete the text present in the minibuffer into a longer string that it stands for, by matching it against a set of "completion alternatives" provided by the command reading the argument. `?' is defined to display a list of possible completions of what you have inserted. For example, when `M-x' uses the minibuffer to read the name of a command, it provides a list of all available Emacs command names to complete against. The completion keys match the text in the minibuffer against all the command names, find any additional name characters implied by the ones already present in the minibuffer, and add those characters to the ones you have given. This is what makes it possible to type `M-x ins SPC b RET' instead of `M-x insert-buffer RET' (for example). Case is normally significant in completion, because it is significant in most of the names that you can complete (buffer names, file names and command names). Thus, `fo' does not complete to `Foo'. Completion does ignore case distinctions for certain arguments in which case does not matter. * Menu: * Example: Completion Example. * Commands: Completion Commands. * Strict Completion:: * Options: Completion Options. File: emacs, Node: Completion Example, Next: Completion Commands, Up: Completion Completion Example ------------------ A concrete example may help here. If you type `M-x au TAB', the TAB looks for alternatives (in this case, command names) that start with `au'. There are only two: `auto-fill-mode' and `auto-save-mode'. These are the same as far as `auto-', so the `au' in the minibuffer changes to `auto-'. If you type TAB again immediately, there are multiple possibilities for the very next character--it could be `s' or `f'--so no more characters are added; instead, TAB displays a list of all possible completions in another window. If you go on to type `f TAB', this TAB sees `auto-f'. The only command name starting this way is `auto-fill-mode', so completion fills in the rest of that. You now have `auto-fill-mode' in the minibuffer after typing just `au TAB f TAB'. Note that TAB has this effect because in the minibuffer it is bound to the command `minibuffer-complete' when completion is available. File: emacs, Node: Completion Commands, Next: Strict Completion, Prev: Completion Example, Up: Completion Completion Commands ------------------- Here is a list of the completion commands defined in the minibuffer when completion is available. `TAB' Complete the text in the minibuffer as much as possible (`minibuffer-complete'). `SPC' Complete the minibuffer text, but don't go beyond one word (`minibuffer-complete-word'). `RET' Submit the text in the minibuffer as the argument, possibly completing first as described below (`minibuffer-complete-and-exit'). `?' Print a list of all possible completions of the text in the minibuffer (`minibuffer-list-completions'). SPC completes much like TAB, but never goes beyond the next hyphen or space. If you have `auto-f' in the minibuffer and type SPC, it finds that the completion is `auto-fill-mode', but it stops completing after `fill-'. This gives `auto-fill-'. Another SPC at this point completes all the way to `auto-fill-mode'. SPC in the minibuffer when completion is available runs the command `minibuffer-complete-word'. Here are some commands you can use to choose a completion from a window that displays a list of completions: `Mouse-2' Clicking mouse button 2 on a completion in the list of possible completions chooses that completion (`mouse-choose-completion'). You use this command while you are in the minibuffer; but you must click in the list of completions, not in the minibuffer itself. `RET' Typing RET *in the completion list buffer* chooses the completion that point is in or next to (`choose-completion'). To use this command, you must first switch windows to the window that shows the list of completions. File: emacs, Node: Strict Completion, Next: Completion Options, Prev: Completion Commands, Up: Completion Strict Completion ----------------- There are three different ways that RET can work in completing minibuffers, depending on how the argument will be used. * "Strict" completion is used when it is meaningless to give any argument except one of the known alternatives. For example, when `C-x k' reads the name of a buffer to kill, it is meaningless to give anything but the name of an existing buffer. In strict completion, RET refuses to exit if the text in the minibuffer does not complete to an exact match. * "Cautious" completion is similar to strict completion, except that RET exits only if the text was an exact match already, not needing completion. If the text is not an exact match, RET does not exit, but it does complete the text. If it completes to an exact match, a second RET will exit. Cautious completion is used for reading file names for files that must already exist. * "Permissive" completion is used when any string whatever is meaningful, and the list of completion alternatives is just a guide. For example, when `C-x C-f' reads the name of a file to visit, any file name is allowed, in case you want to create a file. In permissive completion, RET takes the text in the minibuffer exactly as given, without completing it. The completion commands display a list of all possible completions in a window whenever there is more than one possibility for the very next character. Also, typing `?' explicitly requests such a list. If the list of completions is long, you can scroll it with `C-M-v' (*note Other Window::.). File: emacs, Node: Completion Options, Prev: Strict Completion, Up: Completion Completion Options ------------------ When completion is done on file names, certain file names are usually ignored. The variable `completion-ignored-extensions' contains a list of strings; a file whose name ends in any of those strings is ignored as a possible completion. The standard value of this variable has several elements including `".o"', `".elc"', `".dvi"' and `"~"'. The effect is that, for example, `foo' can complete to `foo.c' even though `foo.o' exists as well. However, if *all* the possible completions end in "ignored" strings, then they are not ignored. Ignored extensions do not apply to lists of completions--those always mention all possible completions. Normally, a completion command that finds the next character is undetermined automatically displays a list of all possible completions. If the variable `completion-auto-help' is set to `nil', this does not happen, and you must type `?' to display the possible completions. The `complete' library implements a more powerful kind of completion that can complete multiple words at a time. For example, it can complete the command name abbreviation `p-b' into `print-buffer', because no other command starts with two words whose initials are `p' and `b'. To use this library, put `(load "complete")' in your `~/.emacs' file (*note Init File::.). The `icomplete' library does not change what completion does, but it presents a constantly updated display that tells you what completions are available. To use this library, put `(load "icomplete")' in your `~/.emacs' file. File: emacs, Node: Minibuffer History, Next: Repetition, Prev: Completion, Up: Minibuffer Minibuffer History ================== Every argument that you enter with the minibuffer is saved on a "minibuffer history list" so that you can use it again later in another argument. Special commands load the text of an earlier argument in the minibuffer. They discard the old minibuffer contents, so you can think of them as moving through the history of previous arguments. `M-p' Move to the next earlier argument string saved in the minibuffer history (`previous-history-element'). `M-n' Move to the next later argument string saved in the minibuffer history (`next-history-element'). `M-r REGEXP RET' Move to an earlier saved argument in the minibuffer history that has a match for REGEXP (`previous-matching-history-element'). `M-s REGEXP RET' Move to a later saved argument in the minibuffer history that has a match for REGEXP (`next-matching-history-element'). The simplest way to reuse the saved arguments in the history list is to move through the history list one element at a time. While in the minibuffer, type `M-p' (`previous-history-element') to "move to" the next earlier minibuffer input, and use `M-n' (`next-history-element') to "move to" the next later input. The previous input that you fetch from the history entirely replaces the contents of the minibuffer. To use it as the argument, exit the minibuffer as usual with RET. You can also edit the text before you reuse it; this does not change the history element that you "moved" to, but your new argument does go at the end of the history list in its own right. There are also commands to search forward or backward through the history. As of this writing, they search for history elements that match a regular expression that you specify with the minibuffer. `M-r' (`previous-matching-history-element') searches older elements in the history, while `M-s' (`next-matching-history-element') searches newer elements. By special dispensation, these commands can use the minibuffer to read their arguments even though you are already in the minibuffer when you issue them. All uses of the minibuffer record your input on a history list, but there are separate history lists for different kinds of arguments. For example, there is a list for file names, used by all the commands that read file names. There is a list for arguments of commands like `query-replace'. There are several very specific history lists, including one for command names read by M-x and one for compilation commands read by `compile'. Finally, there is one "miscellaneous" history list that most minibuffer arguments use. File: emacs, Node: Repetition, Prev: Minibuffer History, Up: Minibuffer Repeating Minibuffer Commands ============================= Every command that uses the minibuffer at least once is recorded on a special history list, together with the values of its arguments, so that you can repeat the entire command. In particular, every use of `M-x' is recorded there, since `M-x' uses the minibuffer to read the command name. `C-x ESC ESC' Re-execute a recent minibuffer command (`repeat-complex-command'). `M-x list-command-history' Display the entire command history, showing all the commands `C-x ESC ESC' can repeat, most recent first. `C-x ESC ESC' is used to re-execute a recent minibuffer-using command. With no argument, it repeats the last such command. A numeric argument specifies which command to repeat; one means the last one, and larger numbers specify earlier ones. `C-x ESC ESC' works by turning the previous command into a Lisp expression and then entering a minibuffer initialized with the text for that expression. If you type just RET, the command is repeated as before. You can also change the command by editing the Lisp expression. Whatever expression you finally submit is what will be executed. The repeated command is added to the front of the command history unless it is identical to the most recently executed command already there. Even if you don't understand Lisp syntax, it will probably be obvious which command is displayed for repetition. If you do not change the text, it will repeat exactly as before. Once inside the minibuffer for `C-x ESC ESC', you can use the minibuffer history commands (`M-p', `M-n', `M-r', `M-s'; *note Minibuffer History::.) to move through the history list of saved entire commands. After finding the desired previous command, you can edit its expression as usual and then resubmit it by typing RET as usual. The list of previous minibuffer-using commands is stored as a Lisp list in the variable `command-history'. Each element is a Lisp expression which describes one command and its arguments. Lisp programs can reexecute a command by calling `eval' with the `command-history' element. File: emacs, Node: M-x, Next: Help, Prev: Minibuffer, Up: Top Running Commands by Name ************************ The Emacs commands that are used often or that must be quick to type are bound to keys--short sequences of characters--for convenient use. Other Emacs commands that do not need to be brief are not bound to keys; to run them, you must refer to them by name. A command name is, by convention, made up of one or more words, separated by hyphens; for example, `auto-fill-mode' or `manual-entry'. The use of English words makes the command name easier to remember than a key made up of obscure characters, even though it is more characters to type. The way to run a command by name is to start with `M-x', type the command name, and finish it with RET. `M-x' uses the minibuffer to read the command name. RET exits the minibuffer and runs the command. The string `M-x' appears at the beginning of the minibuffer as a "prompt" to remind you to enter the name of a command to be run. *Note Minibuffer::, for full information on the features of the minibuffer. You can use completion to enter the command name. For example, the command `forward-char' can be invoked by name by typing M-x forward-char RET or M-x forw TAB c RET Note that `forward-char' is the same command that you invoke with the key `C-f'. You can run any Emacs command by name using `M-x', whether or not any keys are bound to it. If you type `C-g' while the command name is being read, you cancel the `M-x' command and get out of the minibuffer, ending up at top level. To pass a numeric argument to the command you are invoking with `M-x', specify the numeric argument before the `M-x'. `M-x' passes the argument along to the command it runs. The argument value appears in the prompt while the command name is being read. Normally, when describing a command that is run by name, we omit the RET that is needed to terminate the name. Thus we might speak of `M-x auto-fill-mode' rather than `M-x auto-fill-mode RET'. We mention the RET only when there is a need to emphasize its presence, such as when we show the command together with following arguments. `M-x' works by running the command `execute-extended-command', which is responsible for reading the name of another command and invoking it. File: emacs, Node: Help, Next: Mark, Prev: M-x, Up: Top Help **** Emacs provides extensive help features accessible through a single character, `C-h'. `C-h' is a prefix key that is used only for documentation-printing commands. The characters that you can type after `C-h' are called "help options". One help option is `C-h'; that is how you ask for help about using `C-h'. To cancel, type `C-g'. `C-h C-h' displays a list of the possible help options, each with a brief description. Before you type a help option, you can use SPC or DEL to scroll through the list. `C-h' means "help" in various other contexts as well. For example, in `query-replace', it describes the options available. After a prefix key, it displays a list of the alternatives that can follow the prefix key. (A few prefix keys don't support this because they define other meanings for `C-h'.) * Menu: * Help Summary:: Brief list of all Help commands. * Key Help:: Asking what a key does in Emacs. * Name Help:: Asking about a command, variable or function name. * Apropos:: Asking what pertains to a given topic. * Library Keywords:: Finding Lisp libraries by keywords (topics). * Misc Help:: Other help commands. File: emacs, Node: Help Summary, Next: Key Help, Up: Help Help Summary ============ Here is a summary of the defined help commands. `C-h a REGEXP RET' Display list of commands whose names match REGEXP (`command-apropos'). `C-h b' Display a table of all key bindings in effect now, in this order: minor mode bindings, major mode bindings, and global bindings (`describe-bindings'). `C-h c KEY' Print the name of the command that KEY runs (`describe-key-briefly'). Here `c' stands for `character'. For more extensive information on KEY, use `C-h k'. `C-h f FUNCTION RET' Display documentation on the Lisp function named FUNCTION (`describe-function'). Since commands are Lisp functions, a command name may be used. `C-h i' Run Info, the program for browsing documentation files (`info'). The complete Emacs manual is available on-line in Info. `C-h k KEY' Display name and documentation of the command that KEY runs (`describe-key'). `C-h l' Display a description of the last 100 characters you typed (`view-lossage'). `C-h m' Display documentation of the current major mode (`describe-mode'). `C-h n' Display documentation of Emacs changes, most recent first (`view-emacs-news'). `C-h p' Find packages by topic keyword (`finder-by-keyword'). `C-h s' Display current contents of the syntax table, plus an explanation of what they mean (`describe-syntax'). *Note Syntax::. `C-h t' Enter the Emacs interactive tutorial (`help-with-tutorial'). `C-h v VAR RET' Display the documentation of the Lisp variable VAR (`describe-variable'). `C-h w COMMAND RET' Print which keys run the command named COMMAND (`where-is'). `C-h C-f FUNCTION RET' Enter Info and go to the node documenting the Emacs function FUNCTION (`info-goto-emacs-command-node'). `C-h C-k KEY' Enter Info and go to the node where the key sequence KEY is documented (`info-goto-emacs-key-command-node'). `C-h C-c' Display the copying conditions for GNU Emacs. `C-h C-d' Display information about getting new versions of GNU Emacs. `C-h C-p' Display information about the GNU Project. File: emacs, Node: Key Help, Next: Name Help, Prev: Help Summary, Up: Help Documentation for a Key ======================= The most basic `C-h' options are `C-h c' (`describe-key-briefly') and `C-h k' (`describe-key'). `C-h c KEY' prints in the echo area the name of the command that KEY is bound to. For example, `C-h c C-f' prints `forward-char'. Since command names are chosen to describe what the commands do, this is a good way to get a very brief description of what KEY does. `C-h k KEY' is similar but gives more information: it displays the documentation string of the command as well as its name. This is too big for the echo area, so a window is used for the display. `C-h c' and `C-h k' work for any sort of key sequences, including function keys and mouse events. File: emacs, Node: Name Help, Next: Apropos, Prev: Key Help, Up: Help Help by Command or Variable Name ================================ `C-h f' (`describe-function') reads the name of a Lisp function using the minibuffer, then displays that function's documentation string in a window. Since commands are Lisp functions, you can use this to get the documentation of a command that you know by name. For example, C-h f auto-fill-mode RET displays the documentation of `auto-fill-mode'. This is the only way to get the documentation of a command that is not bound to any key (one which you would normally run using `M-x'). `C-h f' is also useful for Lisp functions that you are planning to use in a Lisp program. For example, if you have just written the expression `(make-vector len)' and want to check that you are using `make-vector' properly, type `C-h f make-vector RET'. Because `C-h f' allows all function names, not just command names, you may find that some of your favorite abbreviations that work in `M-x' don't work in `C-h f'. An abbreviation may be unique among command names yet fail to be unique when other function names are allowed. The function name for `C-h f' to describe has a default which is used if you type RET leaving the minibuffer empty. The default is the function called by the innermost Lisp expression in the buffer around point, *provided* that is a valid, defined Lisp function name. For example, if point is located following the text `(make-vector (car x)', the innermost list containing point is the one that starts with `(make-vector', so the default is to describe the function `make-vector'. `C-h f' is often useful just to verify that you have the right spelling for the function name. If `C-h f' mentions a default in the prompt, you have typed the name of a defined Lisp function. If that is all you want to know, just type `C-g' to cancel the `C-h f' command, then go on editing. `C-h w COMMAND RET' tells you what keys are bound to COMMAND. It prints a list of the keys in the echo area. If it says the command is not on any key, you must use `M-x' to run it. `C-h w' runs the command `where-is'. `C-h v' (`describe-variable') is like `C-h f' but describes Lisp variables instead of Lisp functions. Its default is the Lisp symbol around or before point, but only if that is the name of a known Lisp variable. *Note Variables::. File: emacs, Node: Apropos, Next: Library Keywords, Prev: Name Help, Up: Help Apropos ======= A more sophisticated sort of question to ask is, "What are the commands for working with files?" To ask this question, type `C-h a file RET', which displays a list of all command names that contain `file', including `copy-file', `find-file', and so on. With each command name appears a brief description of how to use the command, and what keys you can currently invoke it with. For example, it would say that you can invoke `find-file' by typing `C-x C-f'. The `a' in `C-h a' stands for `Apropos'; `C-h a' runs the command `command-apropos'. Because `C-h a' looks only for functions whose names contain the string which you specify, you must use ingenuity in choosing the string. If you are looking for commands for killing backwards and `C-h a kill-backwards RET' doesn't reveal any, don't give up. Try just `kill', or just `backwards', or just `back'. Be persistent. Also note that you can use a regular expression as the argument, for more flexibility (*note Regexps::.). Here is a set of arguments to give to `C-h a' that covers many classes of Emacs commands, since there are strong conventions for naming the standard Emacs commands. By giving you a feel for the naming conventions, this set should also serve to aid you in developing a technique for picking `apropos' strings. char, line, word, sentence, paragraph, region, page, sexp, list, defun, rect, buffer, frame, window, file, dir, register, mode, beginning, end, forward, backward, next, previous, up, down, search, goto, kill, delete, mark, insert, yank, fill, indent, case, change, set, what, list, find, view, describe. To list all Lisp symbols that contain a match for a regexp, not just the ones that are defined as commands, use the command `M-x apropos' instead of `C-h a'. This command does not check key bindings by default; specify a numeric argument if you want it to check them. The `super-apropos' command is like `apropos' except that it searches documentation strings as well as symbol names for matches for the specified regular expression. File: emacs, Node: Library Keywords, Next: Misc Help, Prev: Apropos, Up: Help Keyword Search for Lisp Libraries ================================= The `C-h p' command lets you search the standard Emacs Lisp libraries by topic keywords. Here is a partial list of keywords you can use: `abbrev' Abbreviation handling, typing shortcuts, macros. `bib' Support for the bibliography processor `bib'. `c' C and C++ language support. `calendar' Calendar and time management support. `comm' Communications, networking, remote access to files. `docs' Support for Emacs documentation. `emulations' Emulations of other editors. `extensions' Emacs Lisp language extensions. `faces' Support for using faces (fonts and colors; *note Faces::.). `games' Games, jokes and amusements. `hardware' Support for interfacing with exotic hardware. `help' Support for on-line help systems. `i18n' Internationalization and alternate character-set support. `internal' Code for Emacs internals, build process, defaults. `languages' Specialized modes for editing programming languages. `lisp' Support for using Lisp (including Emacs Lisp). `local' Libraries local to your site. `maint' Maintenance aids for the Emacs development group. `mail' Modes for electronic-mail handling. `news' Support for netnews reading and posting. `non-text' Support for editing files that are not ordinary text. `processes' Process, subshell, compilation, and job control support. `terminals' Support for terminal types. `tex' Support for the TeX formatter. `tools' Programming tools. `unix' Front-ends/assistants for, or emulators of, Unix features. `vms' Support code for VMS. `wp' Word processing. File: emacs, Node: Misc Help, Prev: Library Keywords, Up: Help Other Help Commands =================== `C-h i' (`info') runs the Info program, which is used for browsing through structured documentation files. The entire Emacs manual is available within Info. Eventually all the documentation of the GNU system will be available. Type `h' after entering Info to run a tutorial on using Info. There are two special help commands for accessing Emacs documentation through Info. `C-h C-f FUNCTION RET' enters Info and goes straight to the documentation of the Emacs function FUNCTION. `C-h C-k KEY' enters Info and goes straight to the documentation of the key KEY. These two keys run the commands `Info-goto-emacs-command-node' and `Info-goto-emacs-key-command-node'. If something surprising happens, and you are not sure what commands you typed, use `C-h l' (`view-lossage'). `C-h l' prints the last 100 command characters you typed in. If you see commands that you don't know, you can use `C-h c' to find out what they do. Emacs has numerous major modes, each of which redefines a few keys and makes a few other changes in how editing works. `C-h m' (`describe-mode') prints documentation on the current major mode, which normally describes all the commands that are changed in this mode. `C-h b' (`describe-bindings') and `C-h s' (`describe-syntax') present other information about the current Emacs mode. `C-h b' displays a list of all the key bindings now in effect; the local bindings defined by the current minor modes first, then the local bindings defined by the current major mode, and finally the global bindings (*note Key Bindings::.). `C-h s' displays the contents of the syntax table, with explanations of each character's syntax (*note Syntax::.). You can get a similar list for a particular prefix key by typing `C-h' after the prefix key. (There are a few prefix keys for which this does not work--those that provide their own bindings for `C-h'. One of these is ESC, because `ESC C-h' is actually `C-M-h', which marks a defun.) The other `C-h' options display various files of useful information. `C-h C-w' displays the full details on the complete absence of warranty for GNU Emacs. `C-h n' (`view-emacs-news') displays the file `emacs/etc/NEWS', which contains documentation on Emacs changes arranged chronologically. `C-h t' (`help-with-tutorial') displays the learn-by-doing Emacs tutorial. `C-h C-c' (`describe-copying') displays the file `emacs/etc/COPYING', which tells you the conditions you must obey in distributing copies of Emacs. `C-h C-d' (`describe-distribution') displays the file `emacs/etc/DISTRIB', which tells you how you can order a copy of the latest version of Emacs. `C-h C-p' (`describe-project') displays general information about the GNU Project. File: emacs, Node: Mark, Next: Killing, Prev: Help, Up: Top The Mark and the Region *********************** Many Emacs commands operate on an arbitrary contiguous part of the current buffer. To specify the text for such a command to operate on, you set "the mark" at one end of it, and move point to the other end. The text between point and the mark is called "the region". You can move point or the mark to adjust the boundaries of the region. It doesn't matter which one is set first chronologically, or which one comes earlier in the text. Once the mark has been set, it remains where you put it until it is set again at another place. The mark remains fixed with respect to the preceding character if text is inserted or deleted in the buffer. Each Emacs buffer has its own mark, so that when you return to a buffer that had been selected previously, it has the same mark it had before. Many commands that insert text, such as `C-y' (`yank') and `M-x insert-buffer', position point and the mark at opposite ends of the inserted text, so that the region contains the text just inserted. Aside from delimiting the region, the mark is also useful for remembering a spot that you may want to go back to. To make this feature more useful, each buffer remembers 16 previous locations of the mark in the "mark ring". * Menu: * Setting Mark:: Commands to set the mark. * Transient Mark:: How to make Emacs highlight the region- when there is one. * Using Region:: Summary of ways to operate on contents of the region. * Marking Objects:: Commands to put region around textual units. * Mark Ring:: Previous mark positions saved so you can go back there. * Global Mark Ring:: Previous mark positions in various buffers. File: emacs, Node: Setting Mark, Next: Transient Mark, Up: Mark Setting the Mark ================ Here are some commands for setting the mark: `C-SPC' Set the mark where point is (`set-mark-command'). `C-@' The same. `C-x C-x' Interchange mark and point (`exchange-point-and-mark'). `Drag-Mouse-1' Set point and the mark around the text you drag across. `Mouse-3' Set mark where you click (`mouse-save-then-kill'). For example, suppose you wish to convert part of the buffer to all upper-case, using the `C-x C-u' (`upcase-region') command which operates on the text in the region. You can first go to the beginning of the text to be capitalized, type `C-SPC' to put the mark there, move to the end, and then type `C-x C-u'. Or, you can set the mark at the end of the text, move to the beginning, and then type `C-x C-u'. The most common way to set the mark is with the `C-SPC' command (`set-mark-command'). This sets the mark where point is. Then you can move point away, leaving the mark behind. There are two ways to set the mark with the mouse. You can drag mouse button one across a range of text; that puts point where you release the mouse button, and sets the mark at the other end of that range. Or you can click mouse button three, which simply sets the mark, leaving point unchanged. Both of these methods copy the region into the kill ring in addition to setting the mark; that gives behavior consistent with other window-driven applications, but if you don't want to modify the kill ring, you must use keyboard commands to set the mark. *Note Mouse Commands::. Ordinary terminals have only one cursor, so there is no way for Emacs to show you where the mark is located. You have to remember. The usual solution to this problem is to set the mark and then use it soon, before you forget where it is. Alternatively, you can see where the mark is with the command `C-x C-x' (`exchange-point-and-mark') which puts the mark where point was and point where the mark was. The extent of the region is unchanged, but the cursor and point are now at the previous position of the mark. In Transient Mark mode, this command reactivates the mark. `C-x C-x' is also useful when you are satisfied with the position of point but want to move the mark; do `C-x C-x' to put point at that end of the region, and then move it. A second use of `C-x C-x', if necessary, puts the mark at the new position with point back at its original position. There is no such character as `C-SPC' in ASCII; when you type SPC while holding down CTRL, what you get on most ordinary terminals is the character `C-@'. This key is actually bound to `set-mark-command'. But unless you are unlucky enough to have a terminal where typing `C-SPC' does not produce `C-@', you might as well think of this character as `C-SPC'. Under X, `C-SPC' is actually a distinct character, but its binding is still `set-mark-command'. File: emacs, Node: Transient Mark, Next: Using Region, Prev: Setting Mark, Up: Mark Transient Mark Mode =================== Many Emacs commands move the mark and invisibly set new regions. This means that there is almost always some region that you can act on. This is convenient, provided you get used to keeping track of the mark's position. Some people prefer a more rigid mode of operation in which you must set up a region for each command that uses one--in which the region "lasts" only temporarily. This is called Transient Mark mode. It is particularly well-suited to window systems such as X, since Emacs can highlight the region when it is active. To enable Transient Mark mode, type `M-x transient-mark-mode'. This command toggles the mode, so you can repeat the command to turn off the mode. Here are the details of Transient Mark mode: * To set the mark, type `C-SPC' (`set-mark-command'). This makes the mark active; as you move point, you will see the region highlighting change in extent. * The mouse commands for specifying the mark also make it active. So do keyboard commands whose purpose is to specify a region, including `M-@', `C-M-@', `M-h', `C-M-h', `C-x C-p', and `C-x h'. * When the mark is active, you can execute commands that operate on the region, such as killing, indentation, or writing to a file. * Any change to the buffer, such as inserting or deleting a character, deactivates the mark. This means any subsequent command that operates on a region will get an error and refuse to operate. You can make the region active again by typing `C-x C-x'. * Commands like `M->' and `C-s' that "leave the mark behind" in addition to some other primary purpose do not activate the new mark. You can activate the new region by executing `C-x C-x' (`exchange-point-and-mark'). * Quitting with `C-g' deactivates the mark. * When Transient Mark mode is not enabled, every command that sets the mark also activates it, and nothing ever deactivates it. Transient Mark mode is also sometimes known as "Zmacs mode" because the Zmacs editor on the MIT Lisp Machine handled the mark in a similar way. When multiple windows show the same buffer, they can have different regions, because they can have different values of point (though they all share common one mark position). In Transient Mark mode, each window highlights its own region. The part that is highlighted in the selected window is the region that editing commands use. *Note Windows::.